// // 懒汉模式实现一：静态指针 + 用到时初始化
// // 代码实例（线程不安全）
// template<typename T>
// class Singleton
// {
// public:
//     static T& getInstance()
//     {
//         if(!_value)
//         {
//             _value = new T();
//         }
//         return *_value;
//     }    
// private:
//     Singleton();
//     ~Singleton();
//     static T* _value;
// };
// template<typename T>
// T* Singleton<T>::_value = NULL;

// // 代码实例
// template<typename T>
// class Singleton
// {
// public:
//     static T& getInstance()
//     {
//         if(!_value)
//         {
//             _value = new T();
//         }
//         return *_value;
//     }
// private:
//     class CGarbo
//     {
//     public:
//         ~CGarbo()
//         {
//             if(Singleton::_value)
//                 delete Singleton::_value;
//         }
//     };
//     Singleton();
//     ~Singleton();
//     static T* _value;
// };

// template<typename T>
// T* Singleton<T>::_value = nullptr;

// 懒汉模式
// #include <iostream>
// #include <mutex>
// #include <thread>
// using namespace std;
 
// class Singleton
// {
// public:
// 	static Singleton* GetInstance() {
// 		// 注意这里一定要使用Double-Check的方式加锁，才能保证效率和线程安全
// 		if (nullptr == m_pInstance) {
// 			m_mtx.lock();
// 			if (nullptr == m_pInstance) {
// 				m_pInstance = new Singleton();
// 			}
// 			m_mtx.unlock();
// 		}
// 		return m_pInstance;
// 	}
	
// 	// 实现一个内嵌垃圾回收类    
// 	class CGarbo {
// 	public:
// 		~CGarbo() {
// 			if (Singleton::m_pInstance)
// 				delete Singleton::m_pInstance;
// 		}
// 	};
// 	// 定义一个静态成员变量，程序结束时，系统会自动调用它的析构函数从而释放单例对象
// 	static CGarbo Garbo;
// private:
// 	// 构造函数私有
// 	Singleton() {};
// 	// 防拷贝
// 	Singleton(Singleton const&);
// 	Singleton& operator=(Singleton const&);
// 	static Singleton* m_pInstance; // 单例对象指针
// 	static mutex m_mtx;   //互斥锁
// };
 
// Singleton* Singleton::m_pInstance = nullptr;
// Singleton::CGarbo Garbo;
// mutex Singleton::m_mtx;
 
// int main()
// {
// 	thread t1([] {cout << Singleton::GetInstance() << endl; });
// 	thread t2([] {cout << Singleton::GetInstance() << endl; });
// 	t1.join();
// 	t2.join();
// 	cout << Singleton::GetInstance() << endl;
// 	cout << Singleton::GetInstance() << endl;
// 	return 0;
// }


#include <iostream>

class Singleton{
public:
    // 获取单例对象的静态方法
    static Singleton* GetInstance(){
        return &instance;// 直接返回已初始化的示例
    }
    // 删除拷贝构造和赋值运算符
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;

private:
    // 私有构造函数
    Singleton(){std::cout << "Singleton instance created!" << std::endl;}
    // C++11 后，可以保证静态局部变量的初始化是线程安全的
    static Singleton instance; // 程序启动初始化
};

// 类外初始化静态成员变量
Singleton Singleton::instance;

int main()
{
    std::cout << "Program starts." << std::endl;

    // 获取单例对象（此时 instance 已经初始化）
    Singleton* s1 = Singleton::GetInstance();
    Singleton* s2 = Singleton::GetInstance();

    std::cout << "s1 address: " << s1 << std::endl;
    std::cout << "s1 address: " << s2 << std::endl;

    return 0;
}